<!DOCTYPE html>
<html class="client-nojs vector-feature-night-mode-disabled vector-feature-language-in-header-enabled vector-feature-language-in-main-page-header-disabled vector-feature-page-tools-pinned-disabled vector-feature-toc-pinned-clientpref-1 vector-feature-main-menu-pinned-disabled vector-feature-limited-width-clientpref-1 vector-feature-limited-width-content-enabled vector-feature-custom-font-size-clientpref-1 vector-feature-appearance-pinned-clientpref-1 vector-sticky-header-enabled" lang="en" dir="ltr"><head>
<meta charset="UTF-8">
<title>Bees algorithm</title>
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="canonical" href="https://en.wikipedia.org/wiki/Bees_algorithm"> <link href="./mw/ext.cite.styles.css" rel="stylesheet" type="text/css">
<link href="./mw/ext.pygments.css" rel="stylesheet" type="text/css">
<link href="./mw/skins.vector.icons.css" rel="stylesheet" type="text/css">
<link href="./mw/skins.vector.search.codex.styles.css" rel="stylesheet" type="text/css">
<link href="./mw/skins.vector.styles.css" rel="stylesheet" type="text/css">
<link href="./mw/user.styles.css" rel="stylesheet" type="text/css">
<meta name="ResourceLoaderDynamicStyles" content="">
<link rel="stylesheet" type="text/css" href="./mw/site.styles.css">
<link rel="stylesheet" type="text/css" href="./mw/noscript.css">
<link rel="stylesheet" type="text/css" href="./footer.css">
<link rel="stylesheet" type="text/css" href="./vector-2022.css">
</head>
<body class="skin--responsive skin-vector skin-vector-search-vue mediawiki ltr sitedir-ltr mw-hide-empty-elt ns-0 ns-subject page-Bees_algorithm rootpage-Bees_algorithm skin-vector-2022 action-view">
<div class="mw-page-container">
<div class="mw-page-container-inner">
<div class="mw-content-container">
<main id="content" class="mw-body">
<header class="mw-body-header vector-page-titlebar">
<h1 id="firstHeading" class="firstHeading mw-first-heading">
<span id="openzim-page-title" class="mw-page-title-main"><span class="mw-page-title-main">Bees algorithm</span></span>
</h1>
</header>
<a id="top"></a>
<div id="bodyContent" class="vector-body ve-init-mw-desktopArticleTarget-targetContainer" aria-labelledby="firstHeading" data-mw-ve-target-container="">
<div id="mw-content-text" class="mw-body-content mw-content-ltr" lang="en" dir="ltr"><div class="mw-content-ltr mw-parser-output" lang="en" dir="ltr">
<style data-mw-deduplicate="TemplateStyles:r1236090951">
/* start https://en.wikipedia.org/ */
.mw-parser-output .hatnote{font-style:italic}.mw-parser-output div.hatnote{padding-left:1.6em;margin-bottom:0.5em}.mw-parser-output .hatnote i{font-style:normal}.mw-parser-output .hatnote+link+.hatnote{margin-top:-0.5em}@media print{body.ns-0 .mw-parser-output .hatnote{display:none!important}}
/* end https://en.wikipedia.org/ */
</style><div role="note" class="hatnote navigation-not-searchable">Not to be confused with <a href="Artificial_bee_colony_algorithm" title="Artificial bee colony algorithm">Artificial bee colony algorithm</a>.</div>
<p>In <a href="Computer_science" title="Computer science">computer science</a> and <a href="Operations_research" title="Operations research">operations research</a>, the <b>bees algorithm</b> is a population-based <a href="Search_algorithm" title="Search algorithm">search algorithm</a> which was developed by Pham, Ghanbarzadeh et al. in 2005.<sup id="cite_ref-Pham_&_al,_2005_1-0" class="reference"><a href="#cite_note-Pham_&_al,_2005-1"><span class="cite-bracket">[</span>1<span class="cite-bracket">]</span></a></sup> It mimics the food foraging behaviour of honey bee colonies. In its basic version the algorithm performs a kind of neighbourhood search combined with global search, and can be used for both <a href="Combinatorial_optimization" title="Combinatorial optimization">combinatorial optimization</a> and <a href="Continuous_optimization" title="Continuous optimization">continuous optimization</a>. The only condition for the application of the bees algorithm is that some measure of distance between the solutions is defined. The effectiveness and specific abilities of the bees algorithm have been proven in a number of studies.<sup id="cite_ref-Pham_&_Castellani,_2009_2-0" class="reference"><a href="#cite_note-Pham_&_Castellani,_2009-2"><span class="cite-bracket">[</span>2<span class="cite-bracket">]</span></a></sup><sup id="cite_ref-3" class="reference"><a href="#cite_note-3"><span class="cite-bracket">[</span>3<span class="cite-bracket">]</span></a></sup><sup id="cite_ref-4" class="reference"><a href="#cite_note-4"><span class="cite-bracket">[</span>4<span class="cite-bracket">]</span></a></sup><sup id="cite_ref-Nasrinpour_&_Massah_&_Teshnehlab_2017_5-0" class="reference"><a href="#cite_note-Nasrinpour_&_Massah_&_Teshnehlab_2017-5"><span class="cite-bracket">[</span>5<span class="cite-bracket">]</span></a></sup><sup id="cite_ref-6" class="reference"><a href="#cite_note-6"><span class="cite-bracket">[</span>6<span class="cite-bracket">]</span></a></sup>
</p>
<meta property="mw:PageProp/toc">
<div class="mw-heading mw-heading2"><h2 id="Metaphor">Metaphor</h2></div>
<p>A colony of <a href="Honey_bees" class="mw-redirect" title="Honey bees">honey bees</a> can extend itself over long distances (over 14 km)<sup id="cite_ref-Tereshko_&_Loengarov,_2005_7-0" class="reference"><a href="#cite_note-Tereshko_&_Loengarov,_2005-7"><span class="cite-bracket">[</span>7<span class="cite-bracket">]</span></a></sup> and in multiple directions simultaneously to harvest nectar or pollen from multiple food sources (flower patches).
A small fraction of the colony constantly searches the environment looking for new flower patches. These scout bees move randomly in the area surrounding the hive, evaluating the profitability (net energy yield) of the food sources encountered.<sup id="cite_ref-Tereshko_&_Loengarov,_2005_7-1" class="reference"><a href="#cite_note-Tereshko_&_Loengarov,_2005-7"><span class="cite-bracket">[</span>7<span class="cite-bracket">]</span></a></sup> When they return to the hive, the scouts deposit the food harvested. Those individuals that found a highly profitable food source go to an area in the hive called the “dance floor”, and perform a ritual known as the <a href="Waggle_dance" title="Waggle dance">waggle dance</a>.<sup id="cite_ref-8" class="reference"><a href="#cite_note-8"><span class="cite-bracket">[</span>8<span class="cite-bracket">]</span></a></sup>
Through the waggle dance a scout bee communicates the location of its discovery to idle onlookers, which join in the exploitation of the flower patch. Since the length of the dance is proportional to the scout’s rating of the food source, more foragers get recruited to harvest the best rated flower patches. After dancing, the scout returns to the food source it discovered to collect more food.
As long as they are evaluated as profitable, rich food sources will be advertised by the scouts when they return to the hive. Recruited foragers may waggle dance as well, increasing the recruitment for highly rewarding flower patches. Thanks to this autocatalytic process, the bee colony is able to quickly switch the focus of the foraging effort on the most profitable flower patches.<sup id="cite_ref-Tereshko_&_Loengarov,_2005_7-2" class="reference"><a href="#cite_note-Tereshko_&_Loengarov,_2005-7"><span class="cite-bracket">[</span>7<span class="cite-bracket">]</span></a></sup>
</p>
<div class="mw-heading mw-heading2"><h2 id="Algorithm">Algorithm</h2></div>
<p>The bees algorithm<sup id="cite_ref-Pham_&_Castellani,_2009_2-1" class="reference"><a href="#cite_note-Pham_&_Castellani,_2009-2"><span class="cite-bracket">[</span>2<span class="cite-bracket">]</span></a></sup><sup id="cite_ref-Pham_&_Ghanbarzadeh_et._a._2006_9-0" class="reference"><a href="#cite_note-Pham_&_Ghanbarzadeh_et._a._2006-9"><span class="cite-bracket">[</span>9<span class="cite-bracket">]</span></a></sup> mimics the foraging strategy of honey bees to look for the best solution to an optimisation problem. Each candidate solution is thought of as a food source (flower), and a population (colony) of <i>n</i> agents (bees) is used to search the solution space. Each time an artificial bee visits a flower (lands on a solution), it evaluates its profitability (fitness).
</p><p>The bees algorithm consists of an initialisation procedure and a main search cycle which is iterated for a given number <i>T</i> of times, or until a solution of acceptable fitness is found. Each search cycle is composed of five procedures: recruitment, local search, neighbourhood shrinking, site abandonment, and global search.
</p>
<pre><b>Pseudocode for the standard bees algorithm</b><sup id="cite_ref-Pham_&_Castellani,_2009_2-2" class="reference"><a href="#cite_note-Pham_&_Castellani,_2009-2"><span class="cite-bracket">[</span>2<span class="cite-bracket">]</span></a></sup>
1 for i = 1, ..., ns
i scout[i] = Initialise_scout()
ii flower_patch[i] = Initialise_flower_patch(scout[i])
2 do until stopping_condition = TRUE
i Recruitment()
ii for i = 1, ..., na
1 flower_patch[i] = Local_search(flower_patch[i])
2 flower_patch[i] = Site_abandonment(flower_patch[i])
3 flower_patch[i] = Neighbourhood_shrinking(flower_patch[i])
iii for i = nb, ..., ns
1 flower_patch[i] = Global_search(flower_patch[i])}
</pre>
<p>In the initialisation routine <i>ns</i> scout bees are randomly placed in the search space, and evaluate the fitness of the solutions where they land. For each solution, a neighbourhood (called flower patch) is delimited.
</p><p>In the recruitment procedure, the scouts that visited the <i>nb</i>≤<i>ns</i> fittest solutions (best sites) perform the waggle dance. That is, they recruit foragers to search further the neighbourhoods of the most promising solutions. The scouts that located the very best <i>ne</i>≤<i>nb</i> solutions (elite sites) recruit <i>nre</i> foragers each, whilst the remaining <i>nb</i>-<i>ne</i> scouts recruit <i>nrb</i>≤<i>nre</i> foragers each. Thus, the number of foragers recruited depends on the profitability of the food source.
</p><p>In the local search procedure, the recruited foragers are randomly scattered within the flower patches enclosing the solutions visited by the scouts (local exploitation). If any of the foragers in a flower patch lands on a solution of higher fitness than the solution visited by the scout, that forager becomes the new scout. If no forager finds a solution of higher fitness, the size of the flower patch is shrunk (neighbourhood shrinking procedure). Usually, flower patches are initially defined over a large area, and their size is gradually shrunk by the neighbourhood shrinking procedure. As a result, the scope of the local exploration is progressively focused on the area immediately close to the local fitness best. If no improvement in fitness is recorded in a given flower patch for a pre-set number of search cycles, the local maximum of fitness is considered found, the patch is abandoned (site abandonment), and a new scout is randomly generated.
</p><p>As in biological bee colonies,<sup id="cite_ref-Tereshko_&_Loengarov,_2005_7-3" class="reference"><a href="#cite_note-Tereshko_&_Loengarov,_2005-7"><span class="cite-bracket">[</span>7<span class="cite-bracket">]</span></a></sup> a small number of scouts keeps exploring the solution space looking for new regions of high fitness (global search). The global search procedure re-initialises the last <i>ns</i>-<i>nb</i> flower patches with randomly generated solutions.
</p><p>At the end of one search cycle, the scout population is again composed of <i>ns</i> scouts: <i>nr</i> scouts produced by the local search procedure (some of which may have been re-initialised by the site abandonment procedure), and <i>ns</i>-<i>nb</i> scouts generated by the global search procedure. The total artificial bee colony size is <i>n</i>=<i>ne</i>•<i>nre</i>+(<i>nb</i>-<i>ne</i>)•<i>nrb</i>+<i>ns</i> (elite sites foragers + remaining best sites foragers + scouts) bees.
</p>
<div class="mw-heading mw-heading2"><h2 id="Variants">Variants</h2></div>
<p>In addition to the basic bees algorithm,<sup id="cite_ref-Pham_&_Ghanbarzadeh_et._a._2006_9-1" class="reference"><a href="#cite_note-Pham_&_Ghanbarzadeh_et._a._2006-9"><span class="cite-bracket">[</span>9<span class="cite-bracket">]</span></a></sup> there are a number of improved or hybrid versions of the BA, each of which focuses on some shortcomings of the basic BA. These variants include (but are not limited to) fuzzy or enhanced BA (EBA),<sup id="cite_ref-Pham_&_Darwish_008_10-0" class="reference"><a href="#cite_note-Pham_&_Darwish_008-10"><span class="cite-bracket">[</span>10<span class="cite-bracket">]</span></a></sup> grouped BA (GBA),<sup id="cite_ref-Nasrinpour_&_Massah_&_Teshnehlab_2017_5-1" class="reference"><a href="#cite_note-Nasrinpour_&_Massah_&_Teshnehlab_2017-5"><span class="cite-bracket">[</span>5<span class="cite-bracket">]</span></a></sup> hybrid modified BA (MBA)<sup id="cite_ref-Pham_&_Pham_&_Castellani_2011_11-0" class="reference"><a href="#cite_note-Pham_&_Pham_&_Castellani_2011-11"><span class="cite-bracket">[</span>11<span class="cite-bracket">]</span></a></sup> and so on.
The pseudo-code for the <b>grouped BA (GBA)</b> <sup id="cite_ref-Nasrinpour_&_Massah_&_Teshnehlab_2017_5-2" class="reference"><a href="#cite_note-Nasrinpour_&_Massah_&_Teshnehlab_2017-5"><span class="cite-bracket">[</span>5<span class="cite-bracket">]</span></a></sup> is as follows.
</p>
<div class="mw-highlight mw-highlight-lang-matlab mw-content-ltr" dir="ltr"><pre><span class="k">function</span><span class="w"> </span><span class="nf">GBA</span>
<span class="w"> </span><span class="c">%% Set the problem parameters</span>
<span class="n">maxIteration</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="p">..;</span><span class="w"> </span><span class="c">% number of iterations (e.g. 1000-5000)</span>
<span class="n">maxParameters</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="p">..;</span><span class="w"> </span><span class="c">% number of input variables</span>
<span class="nb">min</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="p">[..]</span><span class="w"> </span><span class="p">;</span><span class="w"> </span><span class="c">% an array of the size maxParameters to indicate the minimum value of each input parameter </span>
<span class="nb">max</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="p">[..]</span><span class="w"> </span><span class="p">;</span><span class="w"> </span><span class="c">% an array of the size maxParameters to indicate the maximum value of each input parameter</span>
<span class="w"> </span><span class="c">%% Set the grouped bees algorithm (GBA) parameters</span>
<span class="n">R_ngh</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="p">..;</span><span class="w"> </span><span class="c">% patch radius of the neighborhood search for bees in the first group (e.g. 0.001 - 1)</span>
<span class="n">n</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="p">..;</span><span class="w"> </span><span class="c">% number of scout bees (e.g. 4-30)</span>
<span class="n">nGroups</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="p">..;</span><span class="w"> </span><span class="c">% number of groups, excluding the random group</span>
<span class="w"> </span><span class="c">%% GBA's automatic parameter settings</span>
<span class="n">k</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="mi">3</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">/</span><span class="w"> </span><span class="p">((</span><span class="n">nGroups</span><span class="o">+</span><span class="mi">1</span><span class="p">)</span><span class="o">^</span><span class="mi">3</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">);</span><span class="w"> </span><span class="c">% GBA's parameter to set the number of scout bees in each group</span>
<span class="n">groups</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="nb">zeros</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="n">nGroups</span><span class="p">);</span><span class="w"> </span><span class="c">% An array to keep the number of scout bees for each group</span>
<span class="n">recruited_bees</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="nb">zeros</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="n">nGroups</span><span class="p">);</span><span class="w"> </span><span class="c">% An array to keep the number of recruited bees for each group</span>
<span class="n">a</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="p">(((</span><span class="nb">max</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="nb">min</span><span class="p">)</span><span class="w"> </span><span class="o">./</span><span class="w"> </span><span class="mi">2</span><span class="p">)</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="n">R_ngh</span><span class="p">)</span><span class="w"> </span><span class="o">./</span><span class="w"> </span><span class="p">(</span><span class="n">nGroups</span><span class="o">^</span><span class="mi">2</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">);</span><span class="w"> </span><span class="c">% GBA's parameter for setting neighborhood radiuses</span>
<span class="n">b</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="n">R_ngh</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="n">a</span><span class="p">;</span><span class="w"> </span><span class="c">% GBA's parameter for setting neighborhood radiuses</span>
<span class="k">for</span><span class="w"> </span><span class="nb">i</span><span class="p">=</span><span class="mi">1</span><span class="p">:</span><span class="n">nGroups</span><span class="w"> </span><span class="c">% For each group</span>
<span class="w"> </span><span class="n">groups</span><span class="p">(</span><span class="nb">i</span><span class="p">)</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="nb">floor</span><span class="p">(</span><span class="n">k</span><span class="o">*</span><span class="nb">i</span><span class="o">^</span><span class="mi">2</span><span class="p">);</span><span class="w"> </span><span class="c">% determine the number of scout bees in each group</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">groups</span><span class="p">(</span><span class="nb">i</span><span class="p">)</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="mi">0</span>
<span class="w"> </span><span class="n">groups</span><span class="p">(</span><span class="nb">i</span><span class="p">)</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span><span class="w"> </span><span class="c">% there has to be at least one scout bee per each group</span>
<span class="w"> </span><span class="k">end</span>
<span class="w"> </span><span class="n">recruited_bees</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="p">(</span><span class="n">nGroups</span><span class="o">+</span><span class="mi">1</span><span class="o">-</span><span class="nb">i</span><span class="p">)</span><span class="o">^</span><span class="mi">2</span><span class="p">;</span><span class="w"> </span><span class="c">% set the number of recruited bees for each group</span>
<span class="w"> </span><span class="n">ngh</span><span class="p">(</span><span class="nb">i</span><span class="p">)</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nb">i</span><span class="o">*</span><span class="nb">i</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">b</span><span class="p">;</span><span class="w"> </span><span class="c">% set the radius patch for each group</span>
<span class="k">end</span>
<span class="n">group_random</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="nb">sum</span><span class="p">(</span><span class="n">groups</span><span class="p">);</span><span class="w"> </span><span class="c">% assign the remainder bees (if any) to random search</span>
<span class="n">group_random</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="nb">max</span><span class="p">(</span><span class="n">group_random</span><span class="p">,</span><span class="mi">0</span><span class="p">);</span><span class="w"> </span><span class="c">% make sure it is not a negative number</span>
<span class="w"> </span><span class="c">%% initialize the population matrix</span>
<span class="n">population</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="nb">zeros</span><span class="p">(</span><span class="n">n</span><span class="p">,</span><span class="n">maxParameters</span><span class="o">+</span><span class="mi">1</span><span class="p">);</span><span class="w"> </span><span class="c">% A population of n bees including all input variables and their fitness</span>
<span class="k">for</span><span class="w"> </span><span class="nb">i</span><span class="p">=</span><span class="mi">1</span><span class="p">:</span><span class="n">n</span>
<span class="w"> </span><span class="n">population</span><span class="p">(</span><span class="nb">i</span><span class="p">,</span><span class="mi">1</span><span class="p">:</span><span class="n">maxParameters</span><span class="p">)=</span><span class="w"> </span><span class="n">generate_random_solution</span><span class="p">(</span><span class="n">maxParameters</span><span class="p">,</span><span class="nb">min</span><span class="p">,</span><span class="w"> </span><span class="nb">max</span><span class="p">);</span><span class="w"> </span><span class="c">% random initialization of maxParameters variables between max and min</span>
<span class="w"> </span><span class="n">population</span><span class="p">(</span><span class="nb">i</span><span class="p">,</span><span class="n">maxParameters</span><span class="o">+</span><span class="mi">1</span><span class="p">)</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="n">evalulate_fitness</span><span class="p">(</span><span class="n">population</span><span class="p">(</span><span class="nb">i</span><span class="p">,:));</span><span class="w"> </span><span class="c">% fitness evaluation of each solution and saving it at the last index of the population matrix</span>
<span class="k">end</span>
<span class="n">sorted_population</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="nb">sortrows</span><span class="p">(</span><span class="n">population</span><span class="p">);</span><span class="w"> </span><span class="c">% sort the population based on their fitnesses</span>
<span class="w"> </span><span class="c">%% Iterations of the grouped bees algorithm</span>
<span class="k">for</span><span class="w"> </span><span class="nb">i</span><span class="p">=</span><span class="mi">1</span><span class="p">:</span><span class="n">maxIteration</span><span class="w"> </span><span class="c">% GBA's main loop</span>
<span class="w"> </span><span class="n">beeIndex</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span><span class="w"> </span><span class="c">% keep track of all bees (i.e, patches)</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">g</span><span class="p">=</span><span class="mi">1</span><span class="p">:</span><span class="n">nGroups</span><span class="w"> </span><span class="c">% for each group of scout bees</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="nb">j</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="p">:</span><span class="w"> </span><span class="n">groups</span><span class="p">(</span><span class="n">g</span><span class="p">)</span><span class="w"> </span><span class="c">% exploit each patch within each group</span>
<span class="w"> </span><span class="n">beeIndex</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="n">beeIndex</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span><span class="w"> </span><span class="c">% increase the counter per each patch</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="nb">i</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="p">:</span><span class="w"> </span><span class="n">recruited_bees</span><span class="p">(</span><span class="n">g</span><span class="p">)</span><span class="w"> </span><span class="c">% for each recruited bees of the group</span>
<span class="w"> </span><span class="n">solution</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="n">bee_waggle_dance</span><span class="p">(</span><span class="n">sorted_population</span><span class="p">(</span><span class="n">beeIndex</span><span class="p">,</span><span class="mi">1</span><span class="p">:</span><span class="n">maxParameters</span><span class="p">),</span><span class="n">ngh</span><span class="p">(</span><span class="n">g</span><span class="p">));</span><span class="w"> </span><span class="c">% search the neighborhood around selected patch/solution within the radius of ngh</span>
<span class="w"> </span><span class="n">fit</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="n">evaluate_fitness</span><span class="p">(</span><span class="n">solution</span><span class="p">);</span><span class="w"> </span><span class="c">% evaluate the fitness of recently found solution</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">fit</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="n">sorted_population</span><span class="p">(</span><span class="n">beeIndex</span><span class="p">,</span><span class="n">maxParameters</span><span class="o">+</span><span class="mi">1</span><span class="p">)</span><span class="w"> </span><span class="c">% A minimization problem: if a better location/patch/solution is found by the recuiter bee</span>
<span class="w"> </span><span class="n">sorted_population</span><span class="p">(</span><span class="n">beeIndex</span><span class="p">,</span><span class="mi">1</span><span class="w"> </span><span class="p">:</span><span class="w"> </span><span class="n">maxParameters</span><span class="o">+</span><span class="mi">1</span><span class="p">)</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="p">[</span><span class="n">solution</span><span class="p">(</span><span class="mi">1</span><span class="w"> </span><span class="p">:</span><span class="w"> </span><span class="n">maxParameters</span><span class="p">),</span><span class="n">fit</span><span class="p">];</span><span class="w"> </span><span class="c">% copy new solution and its fitness to the sorted population matrix</span>
<span class="w"> </span><span class="k">end</span>
<span class="w"> </span><span class="k">end</span>
<span class="w"> </span><span class="k">end</span>
<span class="w"> </span><span class="k">end</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="nb">i</span><span class="p">=</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="p">:</span><span class="w"> </span><span class="n">group_random</span><span class="w"> </span><span class="c">% For the remaining random bees</span>
<span class="w"> </span><span class="n">beeIndex</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="n">beeIndex</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span>
<span class="w"> </span><span class="n">solution</span><span class="p">(</span><span class="n">beeIndex</span><span class="p">,</span><span class="mi">1</span><span class="p">:</span><span class="n">maxParameters</span><span class="p">)=</span><span class="w"> </span><span class="n">generate_random_solution</span><span class="p">(</span><span class="n">maxParameters</span><span class="p">,</span><span class="nb">min</span><span class="p">,</span><span class="w"> </span><span class="nb">max</span><span class="p">);</span><span class="w"> </span><span class="c">% generate a new random solution at the index beeIndex</span>
<span class="w"> </span><span class="n">solution</span><span class="p">(</span><span class="n">beeIndex</span><span class="p">,</span><span class="n">maxParameters</span><span class="o">+</span><span class="mi">1</span><span class="p">)=</span><span class="w"> </span><span class="n">evaluate_fitness</span><span class="p">(</span><span class="n">solution</span><span class="p">);</span><span class="w"> </span><span class="c">% evaluate its fitness</span>
<span class="w"> </span><span class="n">sorted_population</span><span class="p">(</span><span class="n">beeIndex</span><span class="p">,:)</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="p">[</span><span class="n">solution</span><span class="p">(</span><span class="mi">1</span><span class="w"> </span><span class="p">:</span><span class="w"> </span><span class="n">maxParameters</span><span class="p">),</span><span class="n">fit</span><span class="p">];</span><span class="w"> </span><span class="c">% copy the new random solution and its fitness to the sorted population matrix</span>
<span class="w"> </span><span class="k">end</span>
<span class="w"> </span><span class="n">sorted_population</span><span class="p">=</span><span class="nb">sortrows</span><span class="p">(</span><span class="n">sorted_population</span><span class="p">);</span><span class="w"> </span><span class="c">% sort the population based on their fitnesses</span>
<span class="w"> </span><span class="n">Best_solution_sofar</span><span class="p">=</span><span class="n">sorted_population</span><span class="p">(</span><span class="mi">1</span><span class="p">,:);</span>
<span class="w"> </span><span class="nb">disp</span><span class="p">(</span><span class="s">'Best:'</span><span class="p">);</span><span class="nb">disp</span><span class="p">(</span><span class="n">Best_solution_sofar</span><span class="p">);</span><span class="w"> </span><span class="c">% Display the best solution of current iteration</span>
<span class="k">end</span><span class="w"> </span><span class="c">% end of GBA's main loop </span>
<span class="k">end</span><span class="w"> </span><span class="c">% end of main function</span>
<span class="c">%% Function Bee Waggle Dance</span>
<span class="k">function</span><span class="w"> </span>new_solution<span class="p">=</span><span class="nf">bee_waggle_dance</span><span class="p">(</span>solution, ngh, maxParameters<span class="p">)</span>
<span class="w"> </span><span class="n">new_solution</span><span class="p">(</span><span class="mi">1</span><span class="p">:</span><span class="n">maxParameters</span><span class="p">)</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="p">(</span><span class="n">solution</span><span class="o">-</span><span class="n">ngh</span><span class="p">)</span><span class="o">+</span><span class="p">(</span><span class="mi">2</span><span class="o">*</span><span class="n">ngh</span><span class="o">.*</span><span class="nb">rand</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="n">maxParameters</span><span class="p">));</span>
<span class="k">end</span>
</pre></div>
<div class="mw-heading mw-heading2"><h2 id="See_also">See also</h2></div>
<ul><li><a href="Ant_colony_optimization_algorithms" title="Ant colony optimization algorithms">Ant colony optimization algorithms</a></li>
<li><a href="Artificial_bee_colony_algorithm" title="Artificial bee colony algorithm">Artificial bee colony algorithm</a></li>
<li><a href="Evolutionary_computation" title="Evolutionary computation">Evolutionary computation</a></li>
<li><a href="L%C3%A9vy_flight_foraging_hypothesis" title="Lévy flight foraging hypothesis">Lévy flight foraging hypothesis</a></li>
<li><a href="Manufacturing_Engineering_Centre" title="Manufacturing Engineering Centre">Manufacturing Engineering Centre</a></li>
<li><a href="Mathematical_optimization" title="Mathematical optimization">Mathematical optimization</a></li>
<li><a href="Metaheuristic" title="Metaheuristic">Metaheuristic</a></li>
<li><a href="Particle_swarm_optimization" title="Particle swarm optimization">Particle swarm optimization</a></li>
<li><a href="Swarm_intelligence" title="Swarm intelligence">Swarm intelligence</a></li></ul>
<div class="mw-heading mw-heading2"><h2 id="References">References</h2></div>
<style data-mw-deduplicate="TemplateStyles:r1239543626">
/* start https://en.wikipedia.org/ */
.mw-parser-output .reflist{margin-bottom:0.5em;list-style-type:decimal}@media screen{.mw-parser-output .reflist{font-size:90%}}.mw-parser-output .reflist .references{font-size:100%;margin-bottom:0;list-style-type:inherit}.mw-parser-output .reflist-columns-2{column-width:30em}.mw-parser-output .reflist-columns-3{column-width:25em}.mw-parser-output .reflist-columns{margin-top:0.3em}.mw-parser-output .reflist-columns ol{margin-top:0}.mw-parser-output .reflist-columns li{page-break-inside:avoid;break-inside:avoid-column}.mw-parser-output .reflist-upper-alpha{list-style-type:upper-alpha}.mw-parser-output .reflist-upper-roman{list-style-type:upper-roman}.mw-parser-output .reflist-lower-alpha{list-style-type:lower-alpha}.mw-parser-output .reflist-lower-greek{list-style-type:lower-greek}.mw-parser-output .reflist-lower-roman{list-style-type:lower-roman}
/* end https://en.wikipedia.org/ */
</style><div class="reflist reflist-columns references-column-width" style="column-width: 30em;">
<ol class="references">
<li id="cite_note-Pham_&_al,_2005-1"><span class="mw-cite-backlink"><b><a href="#cite_ref-Pham_&_al,_2005_1-0">^</a></b></span> <span class="reference-text">Pham DT, Ghanbarzadeh A, Koc E, Otri S, Rahim S and Zaidi M. The Bees Algorithm. Technical Note, Manufacturing Engineering Centre, Cardiff University, UK, 2005.</span>
</li>
<li id="cite_note-Pham_&_Castellani,_2009-2"><span class="mw-cite-backlink">^ <a href="#cite_ref-Pham_&_Castellani,_2009_2-0"><sup><i><b>a</b></i></sup></a> <a href="#cite_ref-Pham_&_Castellani,_2009_2-1"><sup><i><b>b</b></i></sup></a> <a href="#cite_ref-Pham_&_Castellani,_2009_2-2"><sup><i><b>c</b></i></sup></a></span> <span class="reference-text">Pham, D.T., Castellani, M. (2009), <a rel="nofollow" class="external text" href="http://pic.sagepub.com/content/223/12/2919.short">The Bees Algorithm – Modelling Foraging Behaviour to Solve Continuous Optimisation Problems</a>. Proc. ImechE, Part C, 223(12), 2919-2938.</span>
</li>
<li id="cite_note-3"><span class="mw-cite-backlink"><b><a href="#cite_ref-3">^</a></b></span> <span class="reference-text">Pham, D.T. and Castellani, M. (2013), <a rel="nofollow" class="external text" href="https://link.springer.com/article/10.1007/s00500-013-1104-9">Benchmarking and Comparison of Nature-Inspired Population-Based Continuous Optimisation Algorithms</a>, Soft Computing, 1-33.</span>
</li>
<li id="cite_note-4"><span class="mw-cite-backlink"><b><a href="#cite_ref-4">^</a></b></span> <span class="reference-text">Pham, D.T. and Castellani, M. (2015), <a rel="nofollow" class="external text" href="http://www.tandfonline.com/doi/abs/10.1080/23311916.2015.1091540">A comparative study of the bees algorithm as a tool for function optimisation</a>, Cogent Engineering 2(1), 1091540.</span>
</li>
<li id="cite_note-Nasrinpour_&_Massah_&_Teshnehlab_2017-5"><span class="mw-cite-backlink">^ <a href="#cite_ref-Nasrinpour_&_Massah_&_Teshnehlab_2017_5-0"><sup><i><b>a</b></i></sup></a> <a href="#cite_ref-Nasrinpour_&_Massah_&_Teshnehlab_2017_5-1"><sup><i><b>b</b></i></sup></a> <a href="#cite_ref-Nasrinpour_&_Massah_&_Teshnehlab_2017_5-2"><sup><i><b>c</b></i></sup></a></span> <span class="reference-text">Nasrinpour, H. R., Massah Bavani, A., Teshnehlab, M., (2017), <a rel="nofollow" class="external text" href="http://www.mdpi.com/2073-431X/6/1/5">Grouped Bees Algorithm: A Grouped Version of the Bees Algorithm</a>, Computers 2017, 6(1), 5; (<style data-mw-deduplicate="TemplateStyles:r1238218222">
/* start https://en.wikipedia.org/ */
.mw-parser-output cite.citation{font-style:inherit;word-wrap:break-word}.mw-parser-output .citation q{quotes:"\"""\"""'""'"}.mw-parser-output .citation:target{background-color:rgba(0,127,255,0.133)}.mw-parser-output .id-lock-free.id-lock-free a{background:url("./mw/Lock-green.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-limited.id-lock-limited a,.mw-parser-output .id-lock-registration.id-lock-registration a{background:url("./mw/Lock-gray-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-subscription.id-lock-subscription a{background:url("./mw/Lock-red-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .cs1-ws-icon a{background:url("./mw/Wikisource-logo.svg")right 0.1em center/12px no-repeat}body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-free a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-limited a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-registration a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-subscription a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .cs1-ws-icon a{background-size:contain;padding:0 1em 0 0}.mw-parser-output .cs1-code{color:inherit;background:inherit;border:none;padding:inherit}.mw-parser-output .cs1-hidden-error{display:none;color:var(--color-error,#d33)}.mw-parser-output .cs1-visible-error{color:var(--color-error,#d33)}.mw-parser-output .cs1-maint{display:none;color:#085;margin-left:0.3em}.mw-parser-output .cs1-kern-left{padding-left:0.2em}.mw-parser-output .cs1-kern-right{padding-right:0.2em}.mw-parser-output .citation .mw-selflink{font-weight:inherit}@media screen{.mw-parser-output .cs1-format{font-size:95%}html.skin-theme-clientpref-night .mw-parser-output .cs1-maint{color:#18911f}}@media screen and (prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .cs1-maint{color:#18911f}}
/* end https://en.wikipedia.org/ */
</style><a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<span class="id-lock-free" title="Freely accessible"><a rel="nofollow" class="external text" href="https://doi.org/10.3390%2Fcomputers6010005">10.3390/computers6010005</a></span>)</span>
</li>
<li id="cite_note-6"><span class="mw-cite-backlink"><b><a href="#cite_ref-6">^</a></b></span> <span class="reference-text">Baronti, Luca & Castellani, Marco & Pham, D.. (2020),<a rel="nofollow" class="external text" href="http://pure-oai.bham.ac.uk/ws/files/100752622/An_Analysis_of_the_Search_Mechanisms_of_the_Bees_Algorithm.pdf.">An Analysis of the Search Mechanisms of the Bees Algorithm.</a>, Swarm and Evolutionary Computation. 59. 100746. 10.1016/j.swevo.2020.100746</span>
</li>
<li id="cite_note-Tereshko_&_Loengarov,_2005-7"><span class="mw-cite-backlink">^ <a href="#cite_ref-Tereshko_&_Loengarov,_2005_7-0"><sup><i><b>a</b></i></sup></a> <a href="#cite_ref-Tereshko_&_Loengarov,_2005_7-1"><sup><i><b>b</b></i></sup></a> <a href="#cite_ref-Tereshko_&_Loengarov,_2005_7-2"><sup><i><b>c</b></i></sup></a> <a href="#cite_ref-Tereshko_&_Loengarov,_2005_7-3"><sup><i><b>d</b></i></sup></a></span> <span class="reference-text">Tereshko V., Loengarov A., (2005) <a rel="nofollow" class="external text" href="http://cis.uws.ac.uk/research/journal/V9/V9N3/bees.pdf">Collective Decision-Making in Honey Bee Foraging Dynamics</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20140201175130/http://cis.uws.ac.uk/research/journal/V9/V9N3/bees.pdf">Archived</a> 2014-02-01 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>. Journal of Computing and Information Systems, 9(3), 1-7.</span>
</li>
<li id="cite_note-8"><span class="mw-cite-backlink"><b><a href="#cite_ref-8">^</a></b></span> <span class="reference-text">Von Frisch, K. (1967) The Dance Language and Orientation of Bees. Harvard University Press, Cambridge, Massachusetts.</span>
</li>
<li id="cite_note-Pham_&_Ghanbarzadeh_et._a._2006-9"><span class="mw-cite-backlink">^ <a href="#cite_ref-Pham_&_Ghanbarzadeh_et._a._2006_9-0"><sup><i><b>a</b></i></sup></a> <a href="#cite_ref-Pham_&_Ghanbarzadeh_et._a._2006_9-1"><sup><i><b>b</b></i></sup></a></span> <span class="reference-text">Pham D.T., Ghanbarzadeh A., Koc E., Otri S., Rahim S., Zaidi M., <a rel="nofollow" class="external text" href="https://web.archive.org/web/20231226051053/https://www.academia.edu/8358231/The_Bees_Algorithm_A_Novel_Tool_for_Complex_Optimisation_Problems">The Bees Algorithm, A Novel Tool for Complex Optimisation Problems</a>, Proc 2nd Int Virtual Conf on Intelligent Production Machines and Systems (IPROMS 2006), Oxford: Elsevier, pp. 454-459, 2006.</span>
</li>
<li id="cite_note-Pham_&_Darwish_008-10"><span class="mw-cite-backlink"><b><a href="#cite_ref-Pham_&_Darwish_008_10-0">^</a></b></span> <span class="reference-text">Pham D. T., Haj Darwish A., (2008), A. <a rel="nofollow" class="external text" href="https://www.researchgate.net/profile/Ahmed_Haj_Darwish/publication/321849894_Fuzzy_Selection_of_Local_Search_Sites_in_the_Bees_Algorithm/links/5a37c834aca272a6ec1e511a/Fuzzy-Selection-of-Local-Search-Sites-in-the-Bees-Algorithm.pdf">Fuzzy Selection of Local Search Sites in the Bees Algorithm</a>. Proceedings of Innovative Production Machines and Systems (IPROMS 2008)</span>
</li>
<li id="cite_note-Pham_&_Pham_&_Castellani_2011-11"><span class="mw-cite-backlink"><b><a href="#cite_ref-Pham_&_Pham_&_Castellani_2011_11-0">^</a></b></span> <span class="reference-text">Pham Q. T., Pham D. T., Castellani M., A modified Bees Algorithm and a statistics-based method for tuning its parameters. Proceedings of the Institution of Mechanical Engineers (ImechE), Part I: Journal of Systems and Control Eng., 2011 (<a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1177%2F0959651811422759">10.1177/0959651811422759</a>)</span>
</li>
</ol></div>
<div class="mw-heading mw-heading2"><h2 id="External_links">External links</h2></div>
<ul><li><a rel="nofollow" class="external text" href="http://beesalgorithmsite.altervista.org/">The bees algorithm website</a></li>
<li><a rel="nofollow" class="external text" href="http://news.bbc.co.uk/1/hi/wales/south_east/5285106.stm">Boffins put dancing bees to work – BBC News</a></li>
<li><a rel="nofollow" class="external text" href="https://sites.google.com/view/baaworkshop/home">The bees algorithm workshop</a></li></ul>
<div class="navbox-styles"><style data-mw-deduplicate="TemplateStyles:r1129693374">
/* start https://en.wikipedia.org/ */
.mw-parser-output .hlist dl,.mw-parser-output .hlist ol,.mw-parser-output .hlist ul{margin:0;padding:0}.mw-parser-output .hlist dd,.mw-parser-output .hlist dt,.mw-parser-output .hlist li{margin:0;display:inline}.mw-parser-output .hlist.inline,.mw-parser-output .hlist.inline dl,.mw-parser-output .hlist.inline ol,.mw-parser-output .hlist.inline ul,.mw-parser-output .hlist dl dl,.mw-parser-output .hlist dl ol,.mw-parser-output .hlist dl ul,.mw-parser-output .hlist ol dl,.mw-parser-output .hlist ol ol,.mw-parser-output .hlist ol ul,.mw-parser-output .hlist ul dl,.mw-parser-output .hlist ul ol,.mw-parser-output .hlist ul ul{display:inline}.mw-parser-output .hlist .mw-empty-li{display:none}.mw-parser-output .hlist dt::after{content:": "}.mw-parser-output .hlist dd::after,.mw-parser-output .hlist li::after{content:" · ";font-weight:bold}.mw-parser-output .hlist dd:last-child::after,.mw-parser-output .hlist dt:last-child::after,.mw-parser-output .hlist li:last-child::after{content:none}.mw-parser-output .hlist dd dd:first-child::before,.mw-parser-output .hlist dd dt:first-child::before,.mw-parser-output .hlist dd li:first-child::before,.mw-parser-output .hlist dt dd:first-child::before,.mw-parser-output .hlist dt dt:first-child::before,.mw-parser-output .hlist dt li:first-child::before,.mw-parser-output .hlist li dd:first-child::before,.mw-parser-output .hlist li dt:first-child::before,.mw-parser-output .hlist li li:first-child::before{content:" (";font-weight:normal}.mw-parser-output .hlist dd dd:last-child::after,.mw-parser-output .hlist dd dt:last-child::after,.mw-parser-output .hlist dd li:last-child::after,.mw-parser-output .hlist dt dd:last-child::after,.mw-parser-output .hlist dt dt:last-child::after,.mw-parser-output .hlist dt li:last-child::after,.mw-parser-output .hlist li dd:last-child::after,.mw-parser-output .hlist li dt:last-child::after,.mw-parser-output .hlist li li:last-child::after{content:")";font-weight:normal}.mw-parser-output .hlist ol{counter-reset:listitem}.mw-parser-output .hlist ol>li{counter-increment:listitem}.mw-parser-output .hlist ol>li::before{content:" "counter(listitem)"\a0 "}.mw-parser-output .hlist dd ol>li:first-child::before,.mw-parser-output .hlist dt ol>li:first-child::before,.mw-parser-output .hlist li ol>li:first-child::before{content:" ("counter(listitem)"\a0 "}
/* end https://en.wikipedia.org/ */
</style><style data-mw-deduplicate="TemplateStyles:r1236075235">
/* start https://en.wikipedia.org/ */
.mw-parser-output .navbox{box-sizing:border-box;border:1px solid #a2a9b1;width:100%;clear:both;font-size:88%;text-align:center;padding:1px;margin:1em auto 0}.mw-parser-output .navbox .navbox{margin-top:0}.mw-parser-output .navbox+.navbox,.mw-parser-output .navbox+.navbox-styles+.navbox{margin-top:-1px}.mw-parser-output .navbox-inner,.mw-parser-output .navbox-subgroup{width:100%}.mw-parser-output .navbox-group,.mw-parser-output .navbox-title,.mw-parser-output .navbox-abovebelow{padding:0.25em 1em;line-height:1.5em;text-align:center}.mw-parser-output .navbox-group{white-space:nowrap;text-align:right}.mw-parser-output .navbox,.mw-parser-output .navbox-subgroup{background-color:#fdfdfd}.mw-parser-output .navbox-list{line-height:1.5em;border-color:#fdfdfd}.mw-parser-output .navbox-list-with-group{text-align:left;border-left-width:2px;border-left-style:solid}.mw-parser-output tr+tr>.navbox-abovebelow,.mw-parser-output tr+tr>.navbox-group,.mw-parser-output tr+tr>.navbox-image,.mw-parser-output tr+tr>.navbox-list{border-top:2px solid #fdfdfd}.mw-parser-output .navbox-title{background-color:#ccf}.mw-parser-output .navbox-abovebelow,.mw-parser-output .navbox-group,.mw-parser-output .navbox-subgroup .navbox-title{background-color:#ddf}.mw-parser-output .navbox-subgroup .navbox-group,.mw-parser-output .navbox-subgroup .navbox-abovebelow{background-color:#e6e6ff}.mw-parser-output .navbox-even{background-color:#f7f7f7}.mw-parser-output .navbox-odd{background-color:transparent}.mw-parser-output .navbox .hlist td dl,.mw-parser-output .navbox .hlist td ol,.mw-parser-output .navbox .hlist td ul,.mw-parser-output .navbox td.hlist dl,.mw-parser-output .navbox td.hlist ol,.mw-parser-output .navbox td.hlist ul{padding:0.125em 0}.mw-parser-output .navbox .navbar{display:block;font-size:100%}.mw-parser-output .navbox-title .navbar{float:left;text-align:left;margin-right:0.5em}body.skin--responsive .mw-parser-output .navbox-image img{max-width:none!important}@media print{body.ns-0 .mw-parser-output .navbox{display:none!important}}
/* end https://en.wikipedia.org/ */
</style></div><div role="navigation" class="navbox" aria-labelledby="Swarming203" style="padding:3px"><table class="nowraplinks mw-collapsible autocollapse navbox-inner" style="border-spacing:0;background:transparent;color:inherit"><tbody><tr><th scope="col" class="navbox-title" colspan="3"><style data-mw-deduplicate="TemplateStyles:r1239400231">
/* start https://en.wikipedia.org/ */
.mw-parser-output .navbar{display:inline;font-size:88%;font-weight:normal}.mw-parser-output .navbar-collapse{float:left;text-align:left}.mw-parser-output .navbar-boxtext{word-spacing:0}.mw-parser-output .navbar ul{display:inline-block;white-space:nowrap;line-height:inherit}.mw-parser-output .navbar-brackets::before{margin-right:-0.125em;content:"[ "}.mw-parser-output .navbar-brackets::after{margin-left:-0.125em;content:" ]"}.mw-parser-output .navbar li{word-spacing:-0.125em}.mw-parser-output .navbar a>span,.mw-parser-output .navbar a>abbr{text-decoration:inherit}.mw-parser-output .navbar-mini abbr{font-variant:small-caps;border-bottom:none;text-decoration:none;cursor:inherit}.mw-parser-output .navbar-ct-full{font-size:114%;margin:0 7em}.mw-parser-output .navbar-ct-mini{font-size:114%;margin:0 4em}html.skin-theme-clientpref-night .mw-parser-output .navbar li a abbr{color:var(--color-base)!important}@media(prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .navbar li a abbr{color:var(--color-base)!important}}@media print{.mw-parser-output .navbar{display:none!important}}
/* end https://en.wikipedia.org/ */
</style><div id="Swarming203" style="font-size:114%;margin:0 4em"><a href="Swarm_behaviour" title="Swarm behaviour">Swarming</a></div></th></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Swarm_behaviour#Biological_swarming" title="Swarm behaviour">Biological swarming</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Agent-based_model_in_biology" title="Agent-based model in biology">Agent-based model in biology</a></li>
<li><a href="Collective_animal_behavior" title="Collective animal behavior">Collective animal behavior</a></li>
<li><a href="Droving" title="Droving">Droving</a></li>
<li><a href="Flock_(birds)" title="Flock (birds)">Flock</a>
<ul><li><a href="Flocking_(behavior)" class="mw-redirect" title="Flocking (behavior)">flocking</a></li>
<li><a href="Sort_sol" title="Sort sol">sort sol</a></li></ul></li>
<li><a href="Herd" title="Herd">Herd</a>
<ul><li><a href="Herd_behavior" title="Herd behavior">herd behavior</a></li></ul></li>
<li><a href="Locust" title="Locust">Locust</a></li>
<li><a href="Mixed-species_foraging_flock" title="Mixed-species foraging flock">Mixed-species foraging flock</a></li>
<li><a href="Mobbing_(animal_behavior)" title="Mobbing (animal behavior)">Mobbing behavior</a>
<ul><li><a href="Feeding_frenzy" title="Feeding frenzy">feeding frenzy</a></li></ul></li>
<li><a href="Pack_(canine)" title="Pack (canine)">Pack</a>
<ul><li><a href="Pack_hunter" title="Pack hunter">pack hunter</a></li></ul></li>
<li><a href="Patterns_of_self-organization_in_ants" title="Patterns of self-organization in ants">Patterns of self-organization in ants</a>
<ul><li><a href="Ant_mill" title="Ant mill">ant mill</a></li>
<li><a href="Symmetry_breaking_of_escaping_ants" title="Symmetry breaking of escaping ants">symmetry breaking of escaping ants</a></li></ul></li>
<li><a href="Shoaling_and_schooling" title="Shoaling and schooling">Shoaling and schooling</a>
<ul><li><a href="Bait_ball" title="Bait ball">bait ball</a></li></ul></li>
<li><a href="Swarm_behaviour" title="Swarm behaviour">Swarming behaviour</a></li>
<li><a href="Swarming_(honey_bee)" title="Swarming (honey bee)">Swarming (honey bee)</a></li>
<li><a href="Swarming_motility" title="Swarming motility">Swarming motility</a></li></ul>
</div></td><td class="noviewer navbox-image" rowspan="6" style="width:1px;padding:0 0 0 2px"><div><span typeof="mw:File"></span></div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Animal_migration" title="Animal migration">Animal migration</a></th><td class="navbox-list-with-group navbox-list navbox-even hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Animal_migration" title="Animal migration">Animal migration</a>
<ul><li><a href="Altitudinal_migration" title="Altitudinal migration">altitudinal</a></li>
<li><a href="Animal_migration_tracking" title="Animal migration tracking">tracking</a>
<ul><li><a href="History_of_wildlife_tracking_technology" title="History of wildlife tracking technology">history</a></li></ul></li>
<li><a href="Coded_wire_tag" title="Coded wire tag">coded wire tag</a></li></ul></li>
<li><a href="Bird_migration" title="Bird migration">Bird migration</a>
<ul><li>flyways</li>
<li><a href="Reverse_migration_(birds)" title="Reverse migration (birds)">reverse migration</a></li></ul></li>
<li><a href="Cell_migration" title="Cell migration">Cell migration</a></li>
<li><a href="Fish_migration" title="Fish migration">Fish migration</a>
<ul><li><a href="Diel_vertical_migration" title="Diel vertical migration">diel vertical</a></li>
<li><a href="Lessepsian_migration" title="Lessepsian migration">Lessepsian</a></li>
<li><a href="Salmon_run" title="Salmon run">salmon run</a></li>
<li><a href="Sardine_run" title="Sardine run">sardine run</a></li></ul></li>
<li><a href="Homing_(biology)" title="Homing (biology)">Homing</a>
<ul><li><a href="Natal_homing" title="Natal homing">natal</a></li>
<li><a href="Philopatry" title="Philopatry">philopatry</a></li></ul></li>
<li><a href="Insect_migration" title="Insect migration">Insect migration</a>
<ul><li><a href="Lepidoptera_migration" title="Lepidoptera migration">butterflies</a>
<ul><li><a href="Monarch_butterfly_migration" title="Monarch butterfly migration">monarch</a></li></ul></li></ul></li>
<li><a href="Sea_turtle_migration" title="Sea turtle migration">Sea turtle migration</a></li></ul>
</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Swarm_behaviour#Models" title="Swarm behaviour">Swarm algorithms</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Agent-based_model" title="Agent-based model">Agent-based models</a></li>
<li><a href="Ant_colony_optimization_algorithm" class="mw-redirect" title="Ant colony optimization algorithm">Ant colony optimization</a></li>
<li><a href="Boids" title="Boids">Boids</a></li>
<li><a href="Crowd_simulation" title="Crowd simulation">Crowd simulation</a></li>
<li><a href="Particle_swarm_optimization" title="Particle swarm optimization">Particle swarm optimization</a></li>
<li><a href="Swarm_intelligence" title="Swarm intelligence">Swarm intelligence</a></li>
<li><a href="Swarm_(simulation)" title="Swarm (simulation)">Swarm (simulation)</a></li></ul>
</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Collective_motion" title="Collective motion">Collective motion</a></th><td class="navbox-list-with-group navbox-list navbox-even hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Active_matter" title="Active matter">Active matter</a></li>
<li><a href="Collective_motion" title="Collective motion">Collective motion</a></li>
<li><a href="Self-propelled_particles" title="Self-propelled particles">Self-propelled particles</a>
<ul><li><a href="Clustering_of_self-propelled_particles" title="Clustering of self-propelled particles">clustering</a></li></ul></li>
<li><a href="Vicsek_model" title="Vicsek model">Vicsek model</a></li>
<li><a href="BIO-LGCA" title="BIO-LGCA">BIO-LGCA</a></li></ul>
</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Swarm_robotics" title="Swarm robotics">Swarm robotics</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Ant_robotics" title="Ant robotics">Ant robotics</a></li>
<li><a href="Microbotics" title="Microbotics">Microbotics</a></li>
<li><a href="Nanorobotics" title="Nanorobotics">Nanorobotics</a></li>
<li><a href="Swarm_robotics" title="Swarm robotics">Swarm robotics</a></li>
<li><a href="Symbrion" title="Symbrion">Symbrion</a></li></ul>
</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">Related topics</th><td class="navbox-list-with-group navbox-list navbox-even hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Allee_effect" title="Allee effect">Allee effect</a></li>
<li><a href="Animal_navigation" title="Animal navigation">Animal navigation</a></li>
<li><a href="Collective_intelligence" title="Collective intelligence">Collective intelligence</a></li>
<li><a href="Decentralised_system" title="Decentralised system">Decentralised system</a></li>
<li><a href="Eusociality" title="Eusociality">Eusociality</a></li>
<li><a href="Group_size_measures" title="Group size measures">Group size measures</a></li>
<li><a href="Microbial_intelligence" title="Microbial intelligence">Microbial intelligence</a></li>
<li><a href="Mutualism_(biology)" title="Mutualism (biology)">Mutualism</a></li>
<li><a href="Predator_satiation" title="Predator satiation">Predator satiation</a></li>
<li><a href="Quorum_sensing" title="Quorum sensing">Quorum sensing</a></li>
<li><a href="Spatial_organization" title="Spatial organization">Spatial organization</a></li>
<li><a href="Stigmergy" title="Stigmergy">Stigmergy</a></li>
<li><a href="Swarming_(military)" title="Swarming (military)">Military swarming</a></li>
<li><a href="Task_allocation_and_partitioning_of_social_insects" class="mw-redirect" title="Task allocation and partitioning of social insects">Task allocation and partitioning of social insects</a></li></ul>
</div></td></tr></tbody></table></div>
<div class="navbox-styles"></div><div role="navigation" class="navbox" aria-labelledby="Optimization:_Algorithms,_methods,_and_heuristics381" style="padding:3px"><table class="nowraplinks hlist mw-collapsible uncollapsed navbox-inner" style="border-spacing:0;background:transparent;color:inherit"><tbody><tr><th scope="col" class="navbox-title" colspan="3"><div id="Optimization:_Algorithms,_methods,_and_heuristics381" style="font-size:114%;margin:0 4em"><a href="Mathematical_optimization" title="Mathematical optimization">Optimization</a>: <a href="Optimization_algorithm" class="mw-redirect" title="Optimization algorithm">Algorithms</a>, <a href="Iterative_method" title="Iterative method">methods</a>, and <a href="Heuristic_algorithm" class="mw-redirect" title="Heuristic algorithm">heuristics</a></div></th></tr><tr><td colspan="2" class="navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em"></div><table class="nowraplinks mw-collapsible mw-collapsed navbox-subgroup" style="border-spacing:0"><tbody><tr><th scope="col" class="navbox-title" colspan="2"><div id="Unconstrained_nonlinear381" style="font-size:114%;margin:0 4em"><a href="Nonlinear_programming" title="Nonlinear programming">Unconstrained nonlinear</a></div></th></tr><tr><td colspan="2" class="navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em"></div><table class="nowraplinks navbox-subgroup" style="border-spacing:0"><tbody><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Function_(mathematics)" title="Function (mathematics)">Functions</a></th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Golden-section_search" title="Golden-section search">Golden-section search</a></li>
<li><a href="Powell's_method" title="Powell's method">Powell's method</a></li>
<li><a href="Line_search" title="Line search">Line search</a></li>
<li><a href="Nelder%E2%80%93Mead_method" title="Nelder–Mead method">Nelder–Mead method</a></li>
<li><a href="Successive_parabolic_interpolation" title="Successive parabolic interpolation">Successive parabolic interpolation</a></li></ul>
</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Gradient" title="Gradient">Gradients</a></th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em"></div><table class="nowraplinks navbox-subgroup" style="border-spacing:0"><tbody><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Local_convergence" title="Local convergence">Convergence</a></th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Trust_region" title="Trust region">Trust region</a></li>
<li><a href="Wolfe_conditions" title="Wolfe conditions">Wolfe conditions</a></li></ul>
</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Quasi-Newton_method" title="Quasi-Newton method">Quasi–Newton</a></th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Berndt%E2%80%93Hall%E2%80%93Hall%E2%80%93Hausman_algorithm" title="Berndt–Hall–Hall–Hausman algorithm">Berndt–Hall–Hall–Hausman</a></li>
<li><a href="Broyden%E2%80%93Fletcher%E2%80%93Goldfarb%E2%80%93Shanno_algorithm" title="Broyden–Fletcher–Goldfarb–Shanno algorithm">Broyden–Fletcher–Goldfarb–Shanno</a> and <a href="Limited-memory_BFGS" title="Limited-memory BFGS">L-BFGS</a></li>
<li><a href="Davidon%E2%80%93Fletcher%E2%80%93Powell_formula" title="Davidon–Fletcher–Powell formula">Davidon–Fletcher–Powell</a></li>
<li><a href="Symmetric_rank-one" title="Symmetric rank-one">Symmetric rank-one (SR1)</a></li></ul>
</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Iterative_method" title="Iterative method">Other methods</a></th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Nonlinear_conjugate_gradient_method" title="Nonlinear conjugate gradient method">Conjugate gradient</a></li>
<li><a href="Gauss%E2%80%93Newton_algorithm" title="Gauss–Newton algorithm">Gauss–Newton</a></li>
<li><a href="Gradient_descent" title="Gradient descent">Gradient</a></li>
<li><a href="Mirror_descent" title="Mirror descent">Mirror</a></li>
<li><a href="Levenberg%E2%80%93Marquardt_algorithm" title="Levenberg–Marquardt algorithm">Levenberg–Marquardt</a></li>
<li><a href="Powell's_dog_leg_method" title="Powell's dog leg method">Powell's dog leg method</a></li>
<li><a href="Truncated_Newton_method" title="Truncated Newton method">Truncated Newton</a></li></ul>
</div></td></tr></tbody></table><div></div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Hessian_matrix" title="Hessian matrix">Hessians</a></th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Newton's_method_in_optimization" title="Newton's method in optimization">Newton's method</a></li></ul>
</div></td></tr></tbody></table><div></div></td></tr></tbody></table><div></div></td><td class="noviewer navbox-image" rowspan="5" style="width:1px;padding:0 0 0 2px"><div></div></td></tr><tr><td colspan="2" class="navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em"></div><table class="nowraplinks mw-collapsible mw-collapsed navbox-subgroup" style="border-spacing:0"><tbody><tr><th scope="col" class="navbox-title" colspan="2"><div id="Constrained_nonlinear381" style="font-size:114%;margin:0 4em"><a href="Nonlinear_programming" title="Nonlinear programming">Constrained nonlinear</a></div></th></tr><tr><td colspan="2" class="navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em"></div><table class="nowraplinks navbox-subgroup" style="border-spacing:0"><tbody><tr><th scope="row" class="navbox-group" style="width:1%">General</th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Barrier_function" title="Barrier function">Barrier methods</a></li>
<li><a href="Penalty_method" title="Penalty method">Penalty methods</a></li></ul>
</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">Differentiable</th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Augmented_Lagrangian_method" title="Augmented Lagrangian method">Augmented Lagrangian methods</a></li>
<li><a href="Sequential_quadratic_programming" title="Sequential quadratic programming">Sequential quadratic programming</a></li>
<li><a href="Successive_linear_programming" title="Successive linear programming">Successive linear programming</a></li></ul>
</div></td></tr></tbody></table><div></div></td></tr></tbody></table><div></div></td></tr><tr><td colspan="2" class="navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em"></div><table class="nowraplinks mw-collapsible mw-collapsed navbox-subgroup" style="border-spacing:0"><tbody><tr><th scope="col" class="navbox-title" colspan="2"><div id="Convex_optimization381" style="font-size:114%;margin:0 4em"><a href="Convex_optimization" title="Convex optimization">Convex optimization</a></div></th></tr><tr><td colspan="2" class="navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em"></div><table class="nowraplinks navbox-subgroup" style="border-spacing:0"><tbody><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Convex_minimization" class="mw-redirect" title="Convex minimization">Convex<br> minimization</a></th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Cutting-plane_method" title="Cutting-plane method">Cutting-plane method</a></li>
<li><a href="Frank%E2%80%93Wolfe_algorithm" title="Frank–Wolfe algorithm">Reduced gradient (Frank–Wolfe)</a></li>
<li><a href="Subgradient_method" title="Subgradient method">Subgradient method</a></li></ul>
</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Linear_programming" title="Linear programming">Linear</a> and<br><a href="Quadratic_programming" title="Quadratic programming">quadratic</a></th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em"></div><table class="nowraplinks navbox-subgroup" style="border-spacing:0"><tbody><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Linear_programming#Interior_point" title="Linear programming">Interior point</a></th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Affine_scaling" title="Affine scaling">Affine scaling</a></li>
<li><a href="Ellipsoid_method" title="Ellipsoid method">Ellipsoid algorithm of Khachiyan</a></li>
<li><a href="Karmarkar's_algorithm" title="Karmarkar's algorithm">Projective algorithm of Karmarkar</a></li></ul>
</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Matroid" title="Matroid">Basis-</a><a href="Exchange_algorithm" class="mw-redirect" title="Exchange algorithm">exchange</a></th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Simplex_algorithm" title="Simplex algorithm">Simplex algorithm of Dantzig</a></li>
<li><a href="Revised_simplex_method" title="Revised simplex method">Revised simplex algorithm</a></li>
<li><a href="Criss-cross_algorithm" title="Criss-cross algorithm">Criss-cross algorithm</a></li>
<li><a href="Lemke's_algorithm" title="Lemke's algorithm">Principal pivoting algorithm of Lemke</a></li>
<li><a href="Active-set_method" title="Active-set method">Active-set method</a></li></ul>
</div></td></tr></tbody></table><div></div></td></tr></tbody></table><div></div></td></tr></tbody></table><div></div></td></tr><tr><td colspan="2" class="navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em"></div><table class="nowraplinks mw-collapsible mw-collapsed navbox-subgroup" style="border-spacing:0"><tbody><tr><th scope="col" class="navbox-title" colspan="2"><div id="Combinatorial381" style="font-size:114%;margin:0 4em"><a href="Combinatorial_optimization" title="Combinatorial optimization">Combinatorial</a></div></th></tr><tr><td colspan="2" class="navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em"></div><table class="nowraplinks navbox-subgroup" style="border-spacing:0"><tbody><tr><th scope="row" class="navbox-group" style="width:1%">Paradigms</th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Approximation_algorithm" title="Approximation algorithm">Approximation algorithm</a></li>
<li><a href="Dynamic_programming" title="Dynamic programming">Dynamic programming</a></li>
<li><a href="Greedy_algorithm" title="Greedy algorithm">Greedy algorithm</a></li>
<li><a href="Integer_programming" title="Integer programming">Integer programming</a>
<ul><li><a href="Branch_and_bound" title="Branch and bound">Branch and bound</a>/<a href="Branch_and_cut" title="Branch and cut">cut</a></li></ul></li></ul>
</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Graph_algorithm" class="mw-redirect" title="Graph algorithm">Graph<br> algorithms</a></th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em"></div><table class="nowraplinks navbox-subgroup" style="border-spacing:0"><tbody><tr><th id="Minimum_spanning_tree52" scope="row" class="navbox-group" style="width:1%"><a href="Minimum_spanning_tree" title="Minimum spanning tree">Minimum<br> spanning tree</a></th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Bor%C5%AFvka's_algorithm" title="Borůvka's algorithm">Borůvka</a></li>
<li><a href="Prim's_algorithm" title="Prim's algorithm">Prim</a></li>
<li><a href="Kruskal's_algorithm" title="Kruskal's algorithm">Kruskal</a></li></ul>
</div></td></tr></tbody></table><div>
</div><table class="nowraplinks navbox-subgroup" style="border-spacing:0"><tbody><tr><th id="Shortest_path39" scope="row" class="navbox-group" style="width:1%"><a href="Shortest_path_problem" title="Shortest path problem">Shortest path</a></th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Bellman%E2%80%93Ford_algorithm" title="Bellman–Ford algorithm">Bellman–Ford</a>
<ul><li><a href="Shortest_Path_Faster_Algorithm" class="mw-redirect" title="Shortest Path Faster Algorithm">SPFA</a></li></ul></li>
<li><a href="Dijkstra's_algorithm" title="Dijkstra's algorithm">Dijkstra</a></li>
<li><a href="Floyd%E2%80%93Warshall_algorithm" title="Floyd–Warshall algorithm">Floyd–Warshall</a></li></ul>
</div></td></tr></tbody></table><div></div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Flow_network" title="Flow network">Network flows</a></th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Dinic's_algorithm" title="Dinic's algorithm">Dinic</a></li>
<li><a href="Edmonds%E2%80%93Karp_algorithm" title="Edmonds–Karp algorithm">Edmonds–Karp</a></li>
<li><a href="Ford%E2%80%93Fulkerson_algorithm" title="Ford–Fulkerson algorithm">Ford–Fulkerson</a></li>
<li><a href="Push%E2%80%93relabel_maximum_flow_algorithm" title="Push–relabel maximum flow algorithm">Push–relabel maximum flow</a></li></ul>
</div></td></tr></tbody></table><div></div></td></tr></tbody></table><div></div></td></tr><tr><td colspan="2" class="navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em"></div><table class="nowraplinks mw-collapsible mw-collapsed navbox-subgroup" style="border-spacing:0"><tbody><tr><th scope="col" class="navbox-title" colspan="2"><div id="Metaheuristics381" style="font-size:114%;margin:0 4em"><a href="Metaheuristic" title="Metaheuristic">Metaheuristics</a></div></th></tr><tr><td colspan="2" class="navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Evolutionary_algorithm" title="Evolutionary algorithm">Evolutionary algorithm</a></li>
<li><a href="Hill_climbing" title="Hill climbing">Hill climbing</a></li>
<li><a href="Local_search_(optimization)" title="Local search (optimization)">Local search</a></li>
<li><a href="Parallel_metaheuristic" title="Parallel metaheuristic">Parallel metaheuristics</a></li>
<li><a href="Simulated_annealing" title="Simulated annealing">Simulated annealing</a></li>
<li><a href="Spiral_optimization_algorithm" title="Spiral optimization algorithm">Spiral optimization algorithm</a></li>
<li><a href="Tabu_search" title="Tabu search">Tabu search</a></li></ul>
</div></td></tr></tbody></table><div></div></td></tr><tr><td class="navbox-abovebelow" colspan="3"><div>
<ul><li><a href="Comparison_of_optimization_software" title="Comparison of optimization software">Software</a></li></ul>
</div></td></tr></tbody></table></div></div><!--htdig_noindex--><div><div class="zim-footer">
This article is issued from <a class="external text" title="Last edited on 2025-06-02" href="https://en.wikipedia.org/wiki/?title=Bees_algorithm&oldid=1293484801">Wikipedia</a>. The text is available under <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.en">Creative Commons Attribution-Share Alike 4.0</a> unless otherwise noted. Additional terms may apply for the media files.
</div>
</div><!--/htdig_noindex--></div>
</div>
</main>
</div>
</div>
</div>
</body></html>